home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / AOCE Sample Code / PowerTalk Access Modules / Sample SMSAM / SampleSMSAM Source / BuildingBlocks / OCEObjects2.cp < prev    next >
Encoding:
Text File  |  1995-07-28  |  60.5 KB  |  2,560 lines  |  [TEXT/KAHL]
  1. /*
  2.     File:        OCEObjects2.cp
  3.  
  4.     Copyright:    © 1991-1994 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Part of the AOCE Sample SMSAM Package.  Consult the license
  8.     which came with this software for your specific legal rights.
  9.  
  10. */
  11.  
  12.  
  13.  
  14. #ifndef __BLJSTANDARDINCLUDES__
  15. #include "BLJStandardIncludes.h"
  16. #endif
  17.  
  18. #ifndef    __OCEOBJECTS__
  19. #include "OCEObjects.h"
  20. #endif
  21.  
  22. #ifndef    __IOSTREAM__
  23. #include "IOStream.h"
  24. #endif
  25.  
  26. #ifndef    __STRING__
  27. #include "String.h"
  28. #endif
  29.  
  30. #ifndef    __SCRIPT__
  31. #include "Script.h"                // for UpperText and LowerText
  32. #endif
  33.  
  34. #ifndef    __FILES__
  35. #include "Files.h"                // for FSWrite & FSRead
  36. #endif
  37.  
  38. #ifndef    __DEBUGASSERT__
  39. #include "DebugAssert.h"        // for ASSERT macros
  40. #endif
  41.  
  42. #ifndef    __NEWDELETE__
  43. #include "NewDelete.h"
  44. #endif
  45.  
  46. #ifndef __THREADUTILITIES__
  47. #include "ThreadUtilities.h"
  48. #endif
  49.  
  50. #ifndef    __ABSTRACTFILE__
  51. #include "AbstractFile.h"
  52. #endif
  53.  
  54. #pragma segment OCEObjects
  55.  
  56. void     SetOCEObjectsInternalValidityChecking ( Boolean state );
  57. Boolean GetOCEObjectsInternalValidityChecking ();
  58.  
  59. /***********************************|****************************************/
  60. /***********************************|****************************************/
  61.  
  62. unsigned short
  63. TRLI::GetPhysicalSize ( const PackedRLI* p )
  64. {
  65.     return ( p ? p->dataLength : 0 ) + sizeof ( ProtoPackedRLI );
  66. }
  67.  
  68. /***********************************|****************************************/
  69.  
  70. unsigned short
  71. TRLI::GetPhysicalSizeOfPacked ( const RLI* r )
  72. {
  73.     return r ? ::OCEPackedRLISize ( r ) : sizeof ( ProtoPackedRLI );
  74. }
  75.  
  76. /***********************************|****************************************/
  77.  
  78. PackedRLI*
  79. TRLI::Allocate ( unsigned short bytes )
  80. {
  81.     PackedRLI* result = (PackedRLI*) FAILNewPtrClear ( bytes );
  82.     result->dataLength = bytes - sizeof(ProtoPackedRLI);
  83.     
  84.     return result;
  85. }
  86.  
  87. /***********************************|****************************************/
  88.  
  89. PackedRLI*
  90. TRLI::Allocate ( const RLI* unpackedSource )
  91. {
  92. #if defined ( INTERNAL_CHECKS )
  93.     ASSERT ( IsValid ( unpackedSource ) );
  94. #endif
  95.     unsigned short packedSize = GetPhysicalSizeOfPacked ( unpackedSource );
  96.     PackedRLI* packedDestination = Allocate ( packedSize );
  97.     ASSERT_RETURN_ZERO ( packedDestination != nil );
  98.     ASSERT_RETURN_ZERO ( ::OCEPackRLI ( unpackedSource, packedDestination, packedSize ) == noErr );
  99.     return packedDestination;
  100. }
  101.  
  102. /***********************************|****************************************/
  103.  
  104. PackedRLI*
  105. TRLI::Allocate ( const PackedRLI* packedSource )
  106. {
  107. #if defined ( INTERNAL_CHECKS )
  108.     ASSERT ( IsValid ( packedSource ) );
  109. #endif
  110.     unsigned short packedSize = GetPhysicalSize ( packedSource );
  111.     PackedRLI* packedDestination = Allocate ( packedSize );
  112.     ASSERT_RETURN_ZERO ( packedDestination != nil );
  113.     ::BlockMove ( packedSource, packedDestination, packedSize );
  114.     return packedDestination;
  115. }
  116.  
  117. /***********************************|****************************************/
  118.  
  119. void
  120. TRLI::Deallocate ( PackedRLI*& p )
  121. {
  122.     if ( p )
  123.     {
  124.         DeallocatePtr( (Ptr) p );
  125. #if defined ( INTERNAL_CHECKS )
  126.         ASSERT ( MemError () == noErr );
  127. #endif
  128.         p = nil;
  129.     }
  130. }
  131.  
  132. /***********************************|****************************************/
  133.  
  134. void
  135. TRLI::Deallocate ()
  136. {
  137.     InvalidateUnpacked ();
  138.     Deallocate ( fPacked );
  139. }
  140.  
  141. /***********************************|****************************************/
  142.  
  143. void
  144. TRLI::ValidateUnpacked () const
  145. {
  146.     if ( !fUnpacked )
  147.     {
  148. #if defined ( INTERNAL_CHECKS )
  149.         ASSERT ( IsValidInternal () );
  150. #endif
  151.  
  152.         if ( fPacked->dataLength == 0 )
  153.         {    
  154.             //    Create an 'empty' unpacked rli.
  155.             ( (TRLI*) this)->fUnpacked->directoryName = nil;
  156.             ( (TRLI*) this)->fUnpacked->discriminator.signature = 0;
  157.             ( (TRLI*) this)->fUnpacked->discriminator.misc = 0;
  158.             ( (TRLI*) this)->fUnpacked->dNodeNumber = 0;
  159.             ( (TRLI*) this)->fUnpacked->path = nil;
  160.         }
  161.         else
  162.         {
  163.             ( (TRLI*) this )->fUnpacked = (RLI*) FAILNewPtrClear ( sizeof ( RLI ) );
  164.         
  165.         
  166.             if ( OCEValidPackedRLI ( fPacked ) )
  167.                 ::OCEUnpackRLI ( fPacked, ( (TRLI*) this )->fUnpacked );
  168.             else
  169.             {
  170.                 keithDB ( "TRLI::ValidateUnpacked, fPacked is invalid." );
  171.             }
  172.         }
  173.                 
  174. #if defined ( INTERNAL_CHECKS )
  175.         ASSERT ( IsValidInternal ( ( (TRLI*) this )->fUnpacked ) );
  176. #endif
  177.     }
  178. }
  179.  
  180. /***********************************|****************************************/
  181.  
  182. Boolean
  183. TRLI::ValidateUnpackedAndCheck () const
  184. {
  185.     ValidateUnpacked ();
  186.     return IsValid ( ( (TRLI*) this )->fUnpacked );
  187. }
  188.  
  189. /***********************************|****************************************/
  190.  
  191. void
  192. TRLI::InvalidateUnpacked () const
  193. {
  194.     if ( fUnpacked )
  195.     {
  196.         ::DeallocatePtr( (Ptr) fUnpacked );
  197. #if defined ( INTERNAL_CHECKS )
  198.         ASSERT ( MemError () == noErr );
  199. #endif
  200.         ( (TRLI*) this )->fUnpacked = nil;
  201.     }
  202. }
  203.  
  204. /***********************************|****************************************/
  205.  
  206. Boolean
  207. TRLI::IsValid ( const RLI* r )
  208. {
  209.     return ( r != nil ) && ::OCEValidRLI ( r );
  210. }
  211.  
  212. /***********************************|****************************************/
  213.  
  214. Boolean
  215. TRLI::IsValid ( const PackedRLI* p )
  216. {
  217.     return ( p != nil ) && ::OCEValidPackedRLI ( p );
  218. }
  219.  
  220. /***********************************|****************************************/
  221.  
  222. #if defined ( INTERNAL_CHECKS )
  223.  
  224. Boolean
  225. TRLI::IsValidInternal ( const RLI* p )
  226. {
  227.     return !GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  228. }
  229.  
  230. /***********************************|****************************************/
  231.  
  232. Boolean
  233. TRLI::IsValidInternal ( const PackedRLI* p )
  234. {
  235.     return !GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  236. }
  237.  
  238. #endif
  239.  
  240. /***********************************|****************************************/
  241.  
  242. TRLI::TRLI ():
  243.     fPacked ( nil ),
  244.     fUnpacked ( nil )
  245. {
  246.     RLI emptyRLI;
  247.     
  248.     memset(&emptyRLI, 0, sizeof(emptyRLI));
  249.     DirectoryName directoryName;
  250.     directoryName.dataLength = 0;
  251.     emptyRLI.directoryName = 0;
  252.     
  253.     fPacked = Allocate ( &emptyRLI );
  254.     
  255. #if defined ( INTERNAL_CHECKS )
  256.     ASSERT ( IsValidInternal () );
  257. #endif
  258. }
  259.  
  260. /***********************************|****************************************/
  261.  
  262. TRLI::TRLI ( const RLI& rli ):
  263.     fPacked ( Allocate ( &rli ) ),
  264.     fUnpacked ( nil )
  265. {
  266. #if defined ( INTERNAL_CHECKS )
  267.     ASSERT ( IsValidInternal () );
  268. #endif
  269. }
  270.  
  271. /***********************************|****************************************/
  272.  
  273. TRLI::TRLI ( const RLI* rli ):
  274.     fPacked ( Allocate ( rli ) ),
  275.     fUnpacked ( nil )
  276. {
  277. #if defined ( INTERNAL_CHECKS )
  278.     ASSERT ( IsValidInternal () );
  279. #endif
  280. }
  281.  
  282. /***********************************|****************************************/
  283.  
  284. TRLI::TRLI ( const PackedRLI& rli ):
  285.     fPacked ( Allocate ( &rli ) ),
  286.     fUnpacked ( nil )
  287. {
  288. #if defined ( INTERNAL_CHECKS )
  289.     ASSERT ( IsValidInternal () );
  290. #endif
  291. }
  292.  
  293. /***********************************|****************************************/
  294.  
  295. TRLI::TRLI ( const PackedRLI* rli ):
  296.     fPacked ( Allocate ( rli ) ),
  297.     fUnpacked ( nil )
  298. {
  299. #if defined ( INTERNAL_CHECKS )
  300.     ASSERT ( IsValidInternal () );
  301. #endif
  302. }
  303.  
  304. /***********************************|****************************************/
  305.  
  306. TRLI::TRLI ( const TDirectory& directory, const TPathName& path, DNodeNum node ):
  307.     fPacked ( nil ),
  308.     fUnpacked ( nil )
  309. {
  310.     RLI rli;
  311.  
  312.     rli.directoryName = (DirectoryName*) (const DirectoryName*) directory.GetName ();
  313.     rli.discriminator = * (DirDiscriminator *) directory.GetDiscriminator ();
  314.     rli.dNodeNumber = node;
  315.     rli.path = (PackedPathName*) (const PackedPathName*) path;
  316.  
  317.     fPacked = Allocate ( &rli );
  318.  
  319. #if defined ( INTERNAL_CHECKS )
  320.     ASSERT ( IsValidInternal () );
  321. #endif
  322. }
  323.  
  324. /***********************************|****************************************/
  325.  
  326. TRLI::TRLI ( const TDirectory& directory, DNodeNum node ):
  327.     fPacked ( nil ),
  328.     fUnpacked ( nil )
  329. {
  330.     RLI rli;
  331.  
  332.     rli.directoryName = (DirectoryName*) (const DirectoryName*) directory.GetName ();
  333.     rli.discriminator = * ( DirDiscriminator *) directory.GetDiscriminator() ;
  334.     rli.dNodeNumber = node;
  335.     rli.path = nil;
  336.  
  337.     fPacked = Allocate ( &rli );
  338.  
  339. #if defined ( INTERNAL_CHECKS )
  340.     ASSERT ( IsValidInternal () );
  341. #endif
  342. }
  343.  
  344. /***********************************|****************************************/
  345.  
  346. TRLI::TRLI ( const TRLI& that ):
  347.     fPacked ( Allocate ( that.fPacked ) ),
  348.     fUnpacked ( nil )
  349. {
  350. #if defined ( INTERNAL_CHECKS )
  351.     ASSERT ( IsValidInternal () );
  352. #endif
  353. }
  354.  
  355. /***********************************|****************************************/
  356.  
  357. TRLI::~TRLI ()
  358. {
  359.     Deallocate ();
  360. }
  361.  
  362. /***********************************|****************************************/
  363.  
  364. TRLI&
  365. TRLI::operator = ( const TRLI& that )
  366. {
  367.     if ( this != &that )
  368.     {
  369.         Deallocate ();
  370.         fPacked = Allocate ( that.fPacked );
  371. #if defined ( INTERNAL_CHECKS )
  372.         ASSERT ( IsValidInternal () );
  373. #endif
  374.     }
  375.  
  376.     return *this;
  377. }
  378.  
  379. /***********************************|****************************************/
  380.  
  381. TRLI&
  382. TRLI::operator = ( const RLI& unpacked )
  383. {
  384.     if ( fUnpacked != &unpacked )
  385.     {
  386.         Deallocate ();
  387.         fPacked = Allocate ( &unpacked );
  388. #if defined ( INTERNAL_CHECKS )
  389.         ASSERT ( IsValidInternal () );
  390. #endif
  391.     }
  392.  
  393.     return *this;
  394. }
  395.  
  396. /***********************************|****************************************/
  397.  
  398. TRLI&
  399. TRLI::operator = ( const PackedRLI& packedSource )
  400. {
  401.     if ( fPacked != &packedSource )
  402.     {
  403.         Deallocate ();
  404.         fPacked = Allocate ( &packedSource );
  405. #if defined ( INTERNAL_CHECKS )
  406.         ASSERT ( IsValidInternal () );
  407. #endif
  408.     }
  409.  
  410.     return *this;
  411. }
  412.  
  413. /***********************************|****************************************/
  414.  
  415. Boolean
  416. TRLI::operator == ( const TRLI& that ) const
  417. {
  418.     return ::OCEEqualPackedRLI ( fPacked, that.fPacked );
  419. }
  420.  
  421. /***********************************|****************************************/
  422.  
  423. Boolean
  424. TRLI::operator != ( const TRLI& that ) const
  425. {
  426.     return !::OCEEqualPackedRLI ( fPacked, that.fPacked );
  427. }
  428.  
  429. /***********************************|****************************************/
  430.  
  431. Boolean
  432. TRLI::operator == ( const PackedRLI& that ) const
  433. {
  434.     return ::OCEEqualPackedRLI ( fPacked, &that );
  435. }
  436.  
  437. /***********************************|****************************************/
  438.  
  439. Boolean
  440. TRLI::operator != ( const PackedRLI& that ) const
  441. {
  442.     return !::OCEEqualPackedRLI ( fPacked, &that );
  443. }
  444.  
  445. /***********************************|****************************************/
  446.  
  447. Boolean
  448. TRLI::operator == ( const RLI& that ) const
  449. {
  450. #if defined ( INTERNAL_CHECKS )
  451.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  452. #endif
  453.     ValidateUnpacked ();
  454.     return OCEEqualRLI ( ( (TRLI*) this )->fUnpacked, &that );
  455. }
  456.  
  457. /***********************************|****************************************/
  458.  
  459. TRLI::operator const RLI* () const
  460. {
  461.     ValidateUnpackedAndCheck ();
  462.     return fUnpacked;
  463. }
  464.  
  465. /***********************************|****************************************/
  466.  
  467. TRLI::operator const RLI& () const
  468. {
  469.     ValidateUnpacked ();
  470.     return *fUnpacked;
  471. }
  472.  
  473. /***********************************|****************************************/
  474.  
  475. void
  476. TRLI::SetDirectory ( const TDirectory& directory )
  477. {
  478. #if defined ( INTERNAL_CHECKS )
  479.     ASSERT_RETURN ( IsValidInternal () );
  480. #endif
  481.     ValidateUnpacked ();
  482.     fUnpacked->directoryName = (DirectoryName*) (const DirectoryName*) directory.GetName ();
  483.     fUnpacked->discriminator = * ( DirDiscriminator *) directory.GetDiscriminator () ;
  484.     PackedRLI* newPacked = Allocate ( fUnpacked );
  485.     ASSERT_RETURN ( newPacked != nil );
  486.     Deallocate ();
  487.     fPacked = newPacked;
  488.     
  489. #if defined ( INTERNAL_CHECKS )
  490.     ASSERT ( IsValidInternal () );
  491. #endif
  492. }
  493.  
  494. /***********************************|****************************************/
  495.  
  496. Boolean
  497. TRLI::GetDirectory ( TDirectory& directory ) const
  498. {
  499. #if defined ( INTERNAL_CHECKS )
  500.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  501. #endif
  502.     ValidateUnpacked ();
  503.     ASSERT_RETURN_ZERO ( fUnpacked->directoryName != nil );
  504.     directory.SetName ( TDirectoryName ( *fUnpacked->directoryName ) );
  505.     directory.SetDiscriminator ( fUnpacked->discriminator );
  506.     return true;
  507. }
  508.  
  509. /***********************************|****************************************/
  510.  
  511. const DirectoryName*
  512. TRLI::GetDirectoryName () const
  513. {
  514. #if defined ( INTERNAL_CHECKS )
  515.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  516. #endif
  517.     ValidateUnpacked ();
  518.     return fUnpacked->directoryName;
  519. }
  520.  
  521. /***********************************|****************************************/
  522.  
  523. const DirDiscriminator&
  524. TRLI::GetDirectoryDiscriminator () const
  525. {
  526. #if defined ( INTERNAL_CHECKS )
  527.     ASSERT ( IsValidInternal () );
  528. #endif
  529.     ValidateUnpacked ();
  530.     return fUnpacked->discriminator;
  531. }
  532.  
  533. /***********************************|****************************************/
  534.  
  535. void
  536. TRLI::SetPathName ( const TPathName& path )
  537. {
  538. #if defined ( INTERNAL_CHECKS )
  539.     ASSERT_RETURN ( IsValidInternal () );
  540. #endif
  541.     ValidateUnpacked ();
  542.     fUnpacked->path = (PackedPathName*) (const PackedPathName*) path;
  543.     PackedRLI* newPacked = Allocate ( fUnpacked );
  544.     ASSERT_RETURN ( newPacked != nil );
  545.     Deallocate ();
  546.     fPacked = newPacked;
  547. #if defined ( INTERNAL_CHECKS )
  548.     ASSERT ( IsValidInternal () );
  549. #endif
  550. }
  551.  
  552. /***********************************|****************************************/
  553.  
  554. Boolean
  555. TRLI::GetPathName ( TPathName& path ) const
  556. {    Boolean result = false;
  557.  
  558. #if defined ( INTERNAL_CHECKS )
  559.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  560. #endif
  561.     ValidateUnpacked ();
  562.     
  563.     #if 1
  564.     if ( fUnpacked->path != nil )
  565.     {
  566.         path = fUnpacked->path;
  567.         result = true;
  568.     }
  569.     
  570.     return result;
  571.     #else
  572.     ASSERT_RETURN_ZERO ( fUnpacked->path != nil );
  573.     path = fUnpacked->path;
  574.     return true;
  575.     #endif
  576. }
  577.  
  578. /***********************************|****************************************/
  579.  
  580. const PackedPathName*
  581. TRLI::GetPathName () const
  582. {
  583. #if defined ( INTERNAL_CHECKS )
  584.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  585. #endif
  586.     ValidateUnpacked ();
  587.     return fUnpacked->path;
  588. }
  589.  
  590. /***********************************|****************************************/
  591.  
  592. void
  593. TRLI::SetNode ( DNodeNum node )
  594. {
  595. #if defined ( INTERNAL_CHECKS )
  596.     ASSERT_RETURN ( IsValidInternal () );
  597. #endif
  598.     ValidateUnpacked ();
  599.     fUnpacked->dNodeNumber = node;
  600.     PackedRLI* newPacked = Allocate ( fUnpacked );
  601.     ASSERT_RETURN ( newPacked != nil );
  602.     Deallocate ();
  603.     fPacked = newPacked;
  604. #if defined ( INTERNAL_CHECKS )
  605.     ASSERT_RETURN ( IsValidInternal () );
  606. #endif
  607. }
  608.  
  609. /***********************************|****************************************/
  610.  
  611. DNodeNum
  612. TRLI::GetNode () const
  613. {
  614. #if defined ( INTERNAL_CHECKS )
  615.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  616. #endif
  617.     ValidateUnpacked ();
  618.     return fUnpacked->dNodeNumber;
  619. }
  620.  
  621. /***********************************|****************************************/
  622.  
  623. Boolean
  624. TRLI::Write ( TAbstractFile& f ) const
  625. {
  626. #if defined ( INTERNAL_CHECKS )
  627.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  628. #endif
  629.     unsigned short physicalSize = GetPhysicalSize ( fPacked );
  630.     ASSERT_RETURN_ZERO ( f.Write ( physicalSize ) == noErr );
  631.     ASSERT_RETURN_ZERO ( f.WriteDataIgnore ( fPacked, physicalSize ) == noErr );
  632.     return true;
  633. }
  634.  
  635. /***********************************|****************************************/
  636.  
  637. Boolean
  638. TRLI::Read ( TAbstractFile& f )
  639. {
  640.     unsigned short physicalSize = 0;
  641.     ASSERT_RETURN_ZERO ( f.Read ( physicalSize ) == noErr );
  642.     ASSERT_RETURN_ZERO ( physicalSize > sizeof ( ProtoPackedRLI ) );
  643.     PackedRLI* p = Allocate ( physicalSize );
  644.     ASSERT_RETURN_ZERO ( p != nil );
  645.     ASSERT_RETURN_ZERO ( f.ReadDataIgnore ( p, physicalSize ) == noErr );
  646.     Deallocate ();
  647.     fPacked = p;
  648. #if defined ( INTERNAL_CHECKS )
  649.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  650. #endif
  651.     return true;
  652. }
  653.  
  654. /***********************************|****************************************/
  655.  
  656. ostream&
  657. TRLI::operator >> ( ostream& s ) const
  658. {
  659.     ValidateUnpacked ();
  660.     s << "directory: " << * fUnpacked->directoryName;
  661.     s << ", discriminator: " << fUnpacked->discriminator;
  662.     s << ", dNodeNumber: " << fUnpacked->dNodeNumber;
  663.     return s << ", path: " << *fUnpacked->path;
  664. }
  665.  
  666. /***********************************|****************************************/
  667. /***********************************|****************************************/
  668.  
  669. unsigned short
  670. TRecordID::GetPhysicalSize ( const PackedRecordID* p )
  671. {
  672.     return ( p ? p->dataLength : 0 ) + sizeof ( ProtoPackedRecordID );
  673. }
  674.  
  675. /***********************************|****************************************/
  676.  
  677. unsigned short
  678. TRecordID::GetPhysicalSizeOfPacked ( const RecordID* r )
  679. {
  680.     return r ? ::OCEPackedRecordIDSize ( r ) : sizeof ( ProtoPackedRecordID );
  681. }
  682.  
  683. /***********************************|****************************************/
  684.  
  685. PackedRecordID*
  686. TRecordID::Allocate ( unsigned short bytes )
  687. {
  688.     return (PackedRecordID*) FAILNewPtrClear ( bytes );
  689. }
  690.  
  691. /***********************************|****************************************/
  692.  
  693. PackedRecordID*
  694. TRecordID::Allocate ( const RecordID* r )
  695. {
  696. #if defined ( INTERNAL_CHECKS )
  697.     ASSERT ( IsValidInternal ( r ) );
  698. #endif
  699.     unsigned short physicalSize = OCEPackedRecordIDSize ( r );
  700.     PackedRecordID* packed = Allocate ( physicalSize );
  701.     ASSERT_RETURN_ZERO ( packed != nil );
  702.     ASSERT_RETURN_ZERO ( OCEPackRecordID ( r, packed, physicalSize ) == noErr );
  703.     return packed;
  704. }
  705.  
  706. /***********************************|****************************************/
  707.  
  708. PackedRecordID*
  709. TRecordID::Allocate ( const PackedRecordID* p )
  710. {
  711. #if defined ( INTERNAL_CHECKS )
  712.     ASSERT_RETURN_ZERO ( IsValidInternal ( p ) );
  713. #endif
  714.     unsigned short physicalSize = GetPhysicalSize ( p );
  715.     PackedRecordID* packed = Allocate ( physicalSize );
  716.     ASSERT_RETURN_ZERO ( packed != nil );
  717.     ::BlockMove ( p, packed, physicalSize );
  718.     return packed;
  719. }
  720.  
  721. /***********************************|****************************************/
  722.  
  723. void
  724. TRecordID::Deallocate ( PackedRecordID*& p )
  725. {
  726.     if ( p )
  727.     {
  728.         ::DeallocatePtr( (Ptr) p );
  729. #if defined ( INTERNAL_CHECKS )
  730.         ASSERT ( MemError () == noErr );
  731. #endif
  732.         p = nil;
  733.     }
  734. }
  735.  
  736. /***********************************|****************************************/
  737.  
  738. void
  739. TRecordID::Deallocate ()
  740. {
  741.     InvalidateUnpacked ();
  742.     Deallocate ( fPacked );
  743. }
  744.  
  745. /***********************************|****************************************/
  746.  
  747. void
  748. TRecordID::ValidateUnpacked () const
  749. {
  750.     if ( !fUnpacked )
  751.     {
  752. #if defined ( INTERNAL_CHECKS )
  753.         ASSERT_RETURN ( IsValidInternal ( fPacked ) );
  754. #endif
  755.         ( (TRecordID*) this )->fUnpacked = (RecordID*) FAILNewPtrClear ( sizeof ( RecordID ) );
  756.         ::OCEUnpackRecordID ( fPacked, ( (TRecordID*) this )->fUnpacked );
  757.     }
  758. }
  759.  
  760. /***********************************|****************************************/
  761.  
  762. Boolean
  763. TRecordID::ValidateUnpackedAndCheck () const
  764. {
  765.     ValidateUnpacked ();
  766.     return IsValid ( fUnpacked );
  767. }
  768.  
  769. /***********************************|****************************************/
  770.  
  771. void
  772. TRecordID::InvalidateUnpacked () const
  773. {
  774.     if ( fUnpacked )
  775.     {
  776.         ::DeallocatePtr( (Ptr) fUnpacked );
  777. #if defined ( INTERNAL_CHECKS )
  778.         ASSERT ( MemError () == noErr );
  779. #endif
  780.         ( (TRecordID*) this )->fUnpacked = nil;
  781.     }
  782. }
  783.  
  784. /***********************************|****************************************/
  785.  
  786. Boolean
  787. TRecordID::IsValid ( const PackedRecordID* p )
  788. {
  789.     return ( p != nil ) && ::OCEValidPackedRecordID ( p );
  790. }
  791.  
  792. /***********************************|****************************************/
  793.  
  794. Boolean
  795. TRecordID::IsValid ( const RecordID* p )
  796. {
  797.     return ( p != nil );
  798. }
  799.  
  800. /***********************************|****************************************/
  801.  
  802. #if defined ( INTERNAL_CHECKS )
  803.  
  804. Boolean
  805. TRecordID::IsValidInternal ( const RecordID* p )
  806. {
  807.     return !GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  808. }
  809.  
  810. /***********************************|****************************************/
  811.  
  812. Boolean
  813. TRecordID::IsValidInternal ( const PackedRecordID* p )
  814. {
  815.     return !GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  816. }
  817.  
  818. #endif
  819.  
  820. /***********************************|****************************************/
  821.  
  822. TRecordID::TRecordID ():
  823.     fPacked ( Allocate ( sizeof ( ProtoPackedRecordID ) ) ),
  824.     fUnpacked ( nil )
  825. {
  826. }
  827.  
  828. /***********************************|****************************************/
  829.  
  830. TRecordID::TRecordID ( const TRecordID& that ):
  831.     fPacked ( Allocate ( that.fPacked ) ),
  832.     fUnpacked ( nil )
  833. {
  834. #if defined ( INTERNAL_CHECKS )
  835.     ASSERT ( IsValidInternal () );
  836. #endif
  837. }
  838.  
  839. /***********************************|****************************************/
  840.  
  841. TRecordID::TRecordID ( const RecordID* r ):
  842.     fPacked ( Allocate ( r ) ),
  843.     fUnpacked ( nil )
  844. {
  845. #if defined ( INTERNAL_CHECKS )
  846.     ASSERT ( IsValidInternal () );
  847. #endif
  848. }
  849.  
  850. /***********************************|****************************************/
  851.  
  852. TRecordID::TRecordID ( const PackedRecordID* r ):
  853.     fPacked ( Allocate ( r ) ),
  854.     fUnpacked ( nil )
  855. {
  856. #if defined ( INTERNAL_CHECKS )
  857.     ASSERT ( IsValidInternal () );
  858. #endif
  859. }
  860.  
  861. /***********************************|****************************************/
  862.  
  863. TRecordID::TRecordID ( const RecordID& r ):
  864.     fPacked ( Allocate ( &r ) ),
  865.     fUnpacked ( nil )
  866. {
  867. #if defined ( INTERNAL_CHECKS )
  868.     ASSERT ( IsValidInternal () );
  869. #endif
  870. }
  871.  
  872. /***********************************|****************************************/
  873.  
  874. TRecordID::TRecordID ( const PackedRecordID& r ):
  875.     fPacked ( Allocate ( &r ) ),
  876.     fUnpacked ( nil )
  877. {
  878. #if defined ( INTERNAL_CHECKS )
  879.     ASSERT ( IsValidInternal () );
  880. #endif
  881. }
  882.  
  883. /***********************************|****************************************/
  884.  
  885. TRecordID::TRecordID ( const TRString& name, const TRString& type, const TPathName& path, const TDirectory& directory ):
  886.     fPacked ( nil ),
  887.     fUnpacked ( nil )
  888. {
  889.     TRLI rli ( directory, path, 0 );
  890.     RecordID r;
  891.  
  892.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  893.     r.local.cid.source = 0;
  894.     r.local.cid.seq = 0;
  895.     r.local.recordName = (RString*) (const RString*) name;
  896.     r.local.recordType = (RString*) (const RString*) type;
  897.  
  898.     fPacked = Allocate ( &r );
  899. #if defined ( INTERNAL_CHECKS )
  900.     ASSERT ( IsValidInternal () );
  901. #endif
  902. }
  903.  
  904. /***********************************|****************************************/
  905.  
  906. TRecordID::TRecordID ( const TRString& name, const TRString& type, const TRLI& rli):
  907.     fPacked ( nil ),
  908.     fUnpacked ( nil )
  909. {
  910.     RecordID r;
  911.  
  912.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  913.     r.local.cid.source = 0;
  914.     r.local.cid.seq = 0;
  915.     r.local.recordName = (RString*) (const RString*) name;
  916.     r.local.recordType = (RString*) (const RString*) type;
  917.  
  918.     fPacked = Allocate ( &r );
  919. #if defined ( INTERNAL_CHECKS )
  920.     ASSERT ( IsValidInternal () );
  921. #endif
  922. }
  923.  
  924. /***********************************|****************************************/
  925.  
  926. TRecordID::TRecordID ( const TRString& name, const TRString& type, const DNodeNum node, const TDirectory& directory):
  927.     fPacked ( nil ),
  928.     fUnpacked ( nil )
  929. {
  930.     TRLI rli ( directory, node );
  931.     RecordID r;
  932.  
  933.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  934.     r.local.cid.source = 0;
  935.     r.local.cid.seq = 0;
  936.     r.local.recordName = (RString*) (const RString*) name;
  937.     r.local.recordType = (RString*) (const RString*) type;
  938.  
  939.     fPacked = Allocate ( &r );
  940. #if defined ( INTERNAL_CHECKS )
  941.     ASSERT ( IsValidInternal () );
  942. #endif
  943. }
  944.  
  945. /***********************************|****************************************/
  946.  
  947. TRecordID::TRecordID ( const TCreationID& cid, const TPathName& path, const TDirectory& directory ):
  948.     fPacked ( nil ),
  949.     fUnpacked ( nil )
  950. {
  951.     TRLI rli ( directory, path );
  952.     RecordID r;
  953.  
  954.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  955.     r.local.cid = (CreationID&) (const CreationID&) cid;
  956.     r.local.recordName = nil;
  957.     r.local.recordType = nil;
  958.  
  959.     fPacked = Allocate ( &r );
  960. #if defined ( INTERNAL_CHECKS )
  961.     ASSERT ( IsValidInternal () );
  962. #endif
  963. }
  964.  
  965. /***********************************|****************************************/
  966.  
  967. TRecordID::TRecordID ( const TCreationID& cid, const DNodeNum node, const TDirectory& directory ):
  968.     fPacked ( nil ),
  969.     fUnpacked ( nil )
  970. {
  971.     TRLI rli ( directory, node );
  972.     RecordID r;
  973.  
  974.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  975.     r.local.cid = (CreationID&) (const CreationID&) cid;
  976.     r.local.recordName = nil;
  977.     r.local.recordType = nil;
  978.  
  979.     fPacked = Allocate ( &r );
  980. #if defined ( INTERNAL_CHECKS )
  981.     ASSERT ( IsValidInternal () );
  982. #endif
  983. }
  984.  
  985. /***********************************|****************************************/
  986.  
  987. TRecordID::TRecordID ( const TCreationID& cid, const TRLI& rli):
  988.     fPacked ( nil ),
  989.     fUnpacked ( nil )
  990. {
  991.     RecordID r;
  992.  
  993.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  994.     r.local.cid = (CreationID&) (const CreationID&) cid;
  995.     r.local.recordName = nil;
  996.     r.local.recordType = nil;
  997.  
  998.     fPacked = Allocate ( &r );
  999. #if defined ( INTERNAL_CHECKS )
  1000.     ASSERT ( IsValidInternal () );
  1001. #endif
  1002. }
  1003.  
  1004. /***********************************|****************************************/
  1005.  
  1006. TRecordID::TRecordID ( const LocalRecordID& localRecordID, const TPathName& p, const TDirectory& directory ):
  1007.     fPacked ( nil ),
  1008.     fUnpacked ( nil )
  1009. {
  1010.     TRLI rli ( directory, p );
  1011.     RecordID r;
  1012.  
  1013.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1014.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1015.     r.local.recordName = localRecordID.recordName;
  1016.     r.local.recordType = localRecordID.recordType;
  1017.  
  1018.     fPacked = Allocate ( &r );
  1019. #if defined ( INTERNAL_CHECKS )
  1020.     ASSERT ( IsValidInternal () );
  1021. #endif
  1022. }
  1023.  
  1024. /***********************************|****************************************/
  1025.  
  1026. TRecordID::TRecordID ( const LocalRecordID& localRecordID, const DNodeNum node, const TDirectory& directory ):
  1027.     fPacked ( nil ),
  1028.     fUnpacked ( nil )
  1029. {
  1030.     TRLI rli ( directory, node );
  1031.     RecordID r;
  1032.  
  1033.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1034.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1035.     r.local.recordName = localRecordID.recordName;
  1036.     r.local.recordType = localRecordID.recordType;
  1037.  
  1038.     fPacked = Allocate ( &r );
  1039. #if defined ( INTERNAL_CHECKS )
  1040.     ASSERT ( IsValidInternal () );
  1041. #endif
  1042. }
  1043.  
  1044. /***********************************|****************************************/
  1045.  
  1046. TRecordID::TRecordID ( const LocalRecordID& localRecordID, const TRLI& rli ):
  1047.     fPacked ( nil ),
  1048.     fUnpacked ( nil )
  1049. {
  1050.     RecordID r;
  1051.  
  1052.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1053.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1054.     r.local.recordName = localRecordID.recordName;
  1055.     r.local.recordType = localRecordID.recordType;
  1056.  
  1057.     fPacked = Allocate ( &r );
  1058. #if defined ( INTERNAL_CHECKS )
  1059.     ASSERT ( IsValidInternal () );
  1060. #endif
  1061. }
  1062.  
  1063. /***********************************|****************************************/
  1064.  
  1065. TRecordID::~TRecordID ()
  1066. {
  1067.     Deallocate ();
  1068. }
  1069.  
  1070. /***********************************|****************************************/
  1071.  
  1072. TRecordID&
  1073. TRecordID::operator = ( const RecordID* r )
  1074. {
  1075. #if defined ( INTERNAL_CHECKS )
  1076.     ASSERT ( r != nil );
  1077. #endif
  1078.  
  1079.     if ( ASSERT ( fUnpacked != r ) )
  1080.     {
  1081.         Deallocate ();
  1082.         fPacked = Allocate ( r );
  1083. #if defined ( INTERNAL_CHECKS )
  1084.         ASSERT ( IsValidInternal () );
  1085. #endif
  1086.     }
  1087.  
  1088.     return *this;
  1089. }
  1090.  
  1091. /***********************************|****************************************/
  1092.  
  1093. TRecordID&
  1094. TRecordID::operator = ( const PackedRecordID* r )
  1095. {
  1096.     if ( ASSERT ( fPacked != r ) )
  1097.     {
  1098.         Deallocate ();
  1099.         fPacked = Allocate ( r );
  1100. #if defined ( INTERNAL_CHECKS )
  1101.         ASSERT ( IsValidInternal () );
  1102. #endif
  1103.     }
  1104.  
  1105.     return *this;
  1106. }
  1107.  
  1108. /***********************************|****************************************/
  1109.  
  1110. Boolean
  1111. TRecordID::operator == ( const RecordID* r ) const
  1112. {
  1113. #if defined ( INTERNAL_CHECKS )
  1114.     if ( ASSERT ( IsValidInternal ( r ) ) )
  1115. #endif
  1116.         if ( ASSERT ( ValidateUnpackedAndCheck () ) )
  1117.             return ::OCEEqualRecordID ( fUnpacked, r );
  1118.  
  1119.     return false;
  1120. }
  1121.  
  1122. /***********************************|****************************************/
  1123.  
  1124. Boolean TRecordID::operator == ( const PackedRecordID* p ) const
  1125. {
  1126. #if defined ( INTERNAL_CHECKS )
  1127.     if ( ASSERT ( IsValidInternal ( p ) ) )
  1128. #endif
  1129.         if ( ASSERT ( IsValidInternal ( fPacked ) ) )
  1130.             return ::OCEEqualPackedRecordID ( fPacked, p );
  1131.  
  1132.     return false;
  1133. }
  1134.  
  1135. /***********************************|****************************************/
  1136.  
  1137. Boolean
  1138. TRecordID::Adopt ( PackedRecordID* p )
  1139. {
  1140.     ASSERT_RETURN_ZERO ( IsValid ( p ) && ( p != fPacked ) );
  1141.     Deallocate ();
  1142.     fPacked = p;
  1143.     return true;
  1144. }
  1145.  
  1146. /***********************************|****************************************/
  1147.  
  1148. Boolean
  1149. TRecordID::Set ( const RecordID* r )
  1150. {
  1151.     // it is quite possible that the RecordID* passed in could
  1152.     // be our unpacked cache, so be careful about deleting or
  1153.     // invalidating or unpacked cache or deleting our pack storage!
  1154.  
  1155. #if defined ( INTERNAL_CHECKS )
  1156.     ASSERT_RETURN_ZERO ( IsValidInternal ( r ) );
  1157. #endif
  1158.     PackedRecordID* newPacked = Allocate ( r );
  1159. #if defined ( INTERNAL_CHECKS )
  1160.     ASSERT_RETURN_ZERO ( IsValidInternal ( newPacked ) );
  1161. #endif
  1162.     Deallocate ();
  1163.     fPacked = newPacked;
  1164.     return true;
  1165. }
  1166.  
  1167. /***********************************|****************************************/
  1168.  
  1169. Boolean
  1170. TRecordID::Set ( const PackedRLI* rli )
  1171. {
  1172. #if defined ( INTERNAL_CHECKS )
  1173.     ASSERT_RETURN_ZERO ( TRLI::IsValid ( rli ) );
  1174. #endif
  1175.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1176.     PackedRLI* prevRLI = fUnpacked->rli;
  1177.     fUnpacked->rli = (PackedRLI*) rli;
  1178.  
  1179.     if ( Set ( fUnpacked ) )
  1180.     {
  1181.         return true;
  1182.     }
  1183.     else
  1184.     {
  1185.         fUnpacked->rli = prevRLI;
  1186.         return false;
  1187.     }
  1188. }
  1189.  
  1190. /***********************************|****************************************/
  1191.  
  1192. Boolean
  1193. TRecordID::SetRecordName ( const TRString& string )
  1194. {
  1195.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1196.     RString* prevName = fUnpacked->local.recordName;
  1197.     fUnpacked->local.recordName = (RString*) (const RString*) string;
  1198.  
  1199.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  1200.     {
  1201.         return true;
  1202.     }
  1203.     else
  1204.     {
  1205.         fUnpacked->local.recordName = prevName;
  1206.         return false;
  1207.     }
  1208. }
  1209.  
  1210. /***********************************|****************************************/
  1211.  
  1212. Boolean
  1213. TRecordID::GetRecordName ( TRString& string ) const
  1214. {
  1215.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1216.     string = fUnpacked->local.recordName;
  1217.     return true;
  1218. }
  1219.  
  1220. /***********************************|****************************************/
  1221.  
  1222. Boolean
  1223. TRecordID::SetRecordType ( const TRString& string )
  1224. {
  1225.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1226.     RString* prevType = fUnpacked->local.recordType;
  1227.     fUnpacked->local.recordType = (RString*) (const RString*) string;
  1228.  
  1229.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  1230.     {
  1231.         return true;
  1232.     }
  1233.     else
  1234.     {
  1235.         fUnpacked->local.recordType = prevType;
  1236.         return false;
  1237.     }
  1238. }
  1239.  
  1240. /***********************************|****************************************/
  1241.  
  1242. Boolean
  1243. TRecordID::GetRecordType ( TRString& string ) const
  1244. {
  1245.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1246.     string = fUnpacked->local.recordType;
  1247.     return true;
  1248. }
  1249.  
  1250. /***********************************|****************************************/
  1251.  
  1252. Boolean
  1253. TRecordID::SetCreationID ( const TCreationID& cid )
  1254. {
  1255.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1256.     CreationID prevID = fUnpacked->local.cid;
  1257.     fUnpacked->local.cid = (CreationID&) (const CreationID&) cid;
  1258.  
  1259.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  1260.     {
  1261.         return true;
  1262.     }
  1263.     else
  1264.     {
  1265.         fUnpacked->local.cid = prevID;
  1266.         return false;
  1267.     }
  1268. }
  1269.  
  1270. /***********************************|****************************************/
  1271.  
  1272. Boolean
  1273. TRecordID::GetCreationID ( TCreationID& cid ) const
  1274. {
  1275.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1276.     cid = fUnpacked->local.cid;
  1277.     return true;
  1278. }
  1279.  
  1280. /***********************************|****************************************/
  1281.  
  1282. Boolean
  1283. TRecordID::SetNode ( const DNodeNum node )
  1284. {
  1285.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1286.     TRLI rli ( fUnpacked->rli );
  1287.     rli.SetNode ( node );
  1288.     return Set ( rli );
  1289. }
  1290.  
  1291. /***********************************|****************************************/
  1292.  
  1293. DNodeNum
  1294. TRecordID::GetNode () const
  1295. {
  1296.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1297.     TRLI rli ( fUnpacked->rli );
  1298.     return rli.GetNode ();
  1299. }
  1300.  
  1301. /***********************************|****************************************/
  1302.  
  1303. Boolean
  1304. TRecordID::SetPathName ( const TPathName& path )
  1305. {
  1306.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1307.     TRLI rli ( fUnpacked->rli );
  1308.     rli.SetPathName ( path );
  1309.     return Set ( rli );
  1310. }
  1311.  
  1312. /***********************************|****************************************/
  1313.  
  1314. Boolean
  1315. TRecordID::GetPathName ( TPathName& path ) const
  1316. {
  1317.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1318.     TRLI rli ( fUnpacked->rli );
  1319.     return rli.GetPathName ( path );
  1320. }
  1321.  
  1322. /***********************************|****************************************/
  1323.  
  1324. Boolean
  1325. TRecordID::SetDirectory ( const TDirectory& directory )
  1326. {
  1327.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1328.     TRLI rli ( fUnpacked->rli );
  1329.     rli.SetDirectory ( directory );
  1330.     return Set ( rli );
  1331. }
  1332.  
  1333. /***********************************|****************************************/
  1334.  
  1335. Boolean
  1336. TRecordID::GetDirectory ( TDirectory& directory ) const
  1337. {
  1338.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1339.     TRLI rli ( fUnpacked->rli );
  1340.     return rli.GetDirectory ( directory );
  1341. }
  1342.  
  1343. /***********************************|****************************************/
  1344.  
  1345. Boolean
  1346. TRecordID::SetRLI ( const TRLI& rli )
  1347. {
  1348.     return Set ( rli );
  1349. }
  1350.  
  1351. /***********************************|****************************************/
  1352.  
  1353. Boolean
  1354. TRecordID::GetRLI ( TRLI& rli ) const
  1355. {
  1356.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  1357.     rli = TRLI ( fUnpacked->rli );
  1358.     return true;
  1359. }
  1360.  
  1361. /***********************************|****************************************/
  1362.  
  1363. TRecordID::operator const RecordID* () const
  1364. {
  1365.     ValidateUnpackedAndCheck ();
  1366.     return fUnpacked;
  1367. }
  1368.  
  1369. /***********************************|****************************************/
  1370.  
  1371. TRecordID::operator const RecordID& () const
  1372. {
  1373.     ValidateUnpacked ();
  1374.     return *fUnpacked;
  1375. }
  1376.  
  1377. /***********************************|****************************************/
  1378.  
  1379. Boolean
  1380. TRecordID::Write ( TAbstractFile& f ) const
  1381. {
  1382. #if defined ( INTERNAL_CHECKS )
  1383.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  1384. #endif
  1385.     unsigned short physicalSize = GetPhysicalSize ( fPacked );
  1386.     ASSERT_RETURN_ZERO ( f.Write ( physicalSize ) == noErr );
  1387.     ASSERT_RETURN_ZERO ( f.WriteDataIgnore ( fPacked, physicalSize ) == noErr );
  1388.     return true;
  1389. }
  1390.  
  1391. /***********************************|****************************************/
  1392.  
  1393. Boolean
  1394. TRecordID::Read ( TAbstractFile& f )
  1395. {
  1396.     unsigned short physicalSize = 0;
  1397.     ASSERT_RETURN_ZERO ( f.Read ( physicalSize ) == noErr );
  1398.     ASSERT_RETURN_ZERO ( physicalSize >= sizeof ( ProtoPackedRecordID ) );
  1399.     PackedRecordID* newPacked = Allocate ( physicalSize );
  1400.     ASSERT_RETURN_ZERO ( newPacked != nil );
  1401.     ASSERT_RETURN_ZERO ( f.ReadDataIgnore ( newPacked, physicalSize ) == noErr );
  1402.     Deallocate ();
  1403.     fPacked = newPacked;
  1404. #if defined ( INTERNAL_CHECKS )
  1405.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  1406. #endif
  1407.     return true;
  1408. }
  1409.  
  1410. /***********************************|****************************************/
  1411.  
  1412. ostream&
  1413. TRecordID::operator >> ( ostream& s ) const
  1414. {
  1415.     if ( ASSERT ( ValidateUnpackedAndCheck () ) )
  1416.     {
  1417.         s << "rli: " << fUnpacked->rli;
  1418.         s << "\ncid: " << fUnpacked->local.cid;
  1419.         s << ", recordName: " << fUnpacked->local.recordName;
  1420.         s << ", recordType: " << fUnpacked->local.recordType;
  1421.     }
  1422.     else
  1423.     {
  1424.         s << "fPacked: " << fPacked;
  1425.     }
  1426.  
  1427.     return s;
  1428. }
  1429.  
  1430. /***********************************|****************************************/
  1431. /***********************************|****************************************/
  1432. /***********************************|****************************************/
  1433. /***********************************|****************************************/
  1434. /***********************************|****************************************/
  1435.  
  1436. unsigned short
  1437. TDSSpec::GetPhysicalSize ( const PackedDSSpec* p )
  1438. {
  1439.     return ( p ? p->dataLength : 0 ) + sizeof ( ProtoPackedDSSpec );
  1440. }
  1441.  
  1442. /***********************************|****************************************/
  1443.  
  1444. unsigned short
  1445. TDSSpec::GetPhysicalSizeOfPacked ( const DSSpec* r )
  1446. {
  1447.     return r ? ::OCEPackedDSSpecSize ( r ) : sizeof ( ProtoPackedDSSpec );
  1448. }
  1449.  
  1450. /***********************************|****************************************/
  1451.  
  1452. PackedDSSpec*
  1453. TDSSpec::Allocate ( unsigned short bytes )
  1454. {
  1455.     return (PackedDSSpec*) FAILNewPtrClear ( bytes );
  1456. }
  1457.  
  1458. /***********************************|****************************************/
  1459.  
  1460. PackedDSSpec*
  1461. TDSSpec::Allocate ( const DSSpec* r )
  1462. {
  1463. #if defined ( INTERNAL_CHECKS )
  1464.     ASSERT ( IsValidInternal ( r ) );
  1465. #endif
  1466.     unsigned short physicalSize = OCEPackedDSSpecSize ( r );
  1467.     PackedDSSpec* packed = Allocate ( physicalSize );
  1468.     ASSERT_RETURN_ZERO ( packed != nil );
  1469.     ASSERT_RETURN_ZERO ( OCEPackDSSpec ( r, packed, physicalSize ) == noErr );
  1470.     return packed;
  1471. }
  1472.  
  1473. /***********************************|****************************************/
  1474.  
  1475. PackedDSSpec*
  1476. TDSSpec::Allocate ( const PackedDSSpec* p )
  1477. {
  1478. #if defined ( INTERNAL_CHECKS )
  1479.     ASSERT_RETURN_ZERO ( IsValidInternal ( p ) );
  1480. #endif
  1481.     unsigned short physicalSize = GetPhysicalSize ( p );
  1482.     PackedDSSpec* packed = Allocate ( physicalSize );
  1483.     ASSERT_RETURN_ZERO ( packed != nil );
  1484.     ::BlockMove ( p, packed, physicalSize );
  1485.     return packed;
  1486. }
  1487.  
  1488. /***********************************|****************************************/
  1489.  
  1490. void
  1491. TDSSpec::Deallocate ( PackedDSSpec*& p )
  1492. {
  1493.     if ( p )
  1494.     {
  1495.         ::DeallocatePtr( (Ptr) p );
  1496. #if defined ( INTERNAL_CHECKS )
  1497.         ASSERT ( MemError () == noErr );
  1498. #endif
  1499.         p = nil;
  1500.     }
  1501. }
  1502.  
  1503. /***********************************|****************************************/
  1504.  
  1505. void
  1506. TDSSpec::Deallocate ()
  1507. {
  1508.     InvalidateUnpacked ();
  1509.     Deallocate ( fPacked );
  1510. }
  1511.  
  1512. /***********************************|****************************************/
  1513.  
  1514. void
  1515. TDSSpec::ValidateUnpacked () const
  1516. {
  1517.     if ( !fUnpacked )
  1518.     {
  1519. #if defined ( INTERNAL_CHECKS )
  1520.         ASSERT_RETURN ( IsValidInternal ( fPacked ) );
  1521. #endif
  1522.         ( (TDSSpec*) this )->fUnpacked = (DSSpec*) FAILNewPtrClear ( sizeof ( DSSpec ) );
  1523.         ( (TDSSpec*) this )->fUnpacked->entitySpecifier = (RecordID*) FAILNewPtrClear ( sizeof ( RecordID ) );
  1524.         ::OCEUnpackDSSpec ( fPacked, ( (TDSSpec*) this )->fUnpacked, 
  1525.                                         ( (TDSSpec*) this )->fUnpacked->entitySpecifier );
  1526.     }
  1527. }
  1528.  
  1529. /***********************************|****************************************/
  1530.  
  1531. Boolean
  1532. TDSSpec::ValidateUnpackedAndCheck () const
  1533. {
  1534.     ValidateUnpacked ();
  1535.     return IsValid ( fUnpacked );
  1536. }
  1537.  
  1538. /***********************************|****************************************/
  1539.  
  1540. void
  1541. TDSSpec::InvalidateUnpacked () const
  1542. {
  1543.     if ( fUnpacked )
  1544.     {
  1545.         ::DeallocatePtr( (Ptr) fUnpacked->entitySpecifier );
  1546. #if defined ( INTERNAL_CHECKS )
  1547.         ASSERT ( MemError () == noErr );
  1548. #endif
  1549.         ::DeallocatePtr( (Ptr) fUnpacked );
  1550. #if defined ( INTERNAL_CHECKS )
  1551.         ASSERT ( MemError () == noErr );
  1552. #endif
  1553.         ( (TDSSpec*) this )->fUnpacked = nil;
  1554.     }
  1555. }
  1556.  
  1557. /***********************************|****************************************/
  1558.  
  1559. Boolean
  1560. TDSSpec::IsValid ( const PackedDSSpec* p )
  1561. {
  1562.     return ( p != nil ) && ::OCEValidPackedDSSpec ( p );
  1563. }
  1564.  
  1565. /***********************************|****************************************/
  1566.  
  1567. Boolean
  1568. TDSSpec::IsValid ( const DSSpec* p )
  1569. {
  1570.     return ( p != nil );
  1571. }
  1572.  
  1573. /***********************************|****************************************/
  1574.  
  1575. #if defined ( INTERNAL_CHECKS )
  1576.  
  1577. Boolean
  1578. TDSSpec::IsValidInternal ( const DSSpec* p )
  1579. {
  1580.     return ! GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  1581. }
  1582.  
  1583. /***********************************|****************************************/
  1584.  
  1585. Boolean
  1586. TDSSpec::IsValidInternal ( const PackedDSSpec* p )
  1587. {
  1588.     return ! GetOCEObjectsInternalValidityChecking() || IsValid ( p );
  1589. }
  1590.  
  1591. #endif
  1592.  
  1593. /***********************************|****************************************/
  1594.  
  1595. TDSSpec::TDSSpec ():
  1596.     fPacked ( Allocate ( sizeof ( ProtoPackedDSSpec ) ) ),
  1597.     fUnpacked ( nil )
  1598. {
  1599. }
  1600.  
  1601. /***********************************|****************************************/
  1602.  
  1603. TDSSpec::TDSSpec ( const TDSSpec& that ):
  1604.     fPacked ( Allocate ( that.fPacked ) ),
  1605.     fUnpacked ( nil )
  1606. {
  1607. #if defined ( INTERNAL_CHECKS )
  1608.     ASSERT ( IsValidInternal () );
  1609. #endif
  1610. }
  1611.  
  1612. /***********************************|****************************************/
  1613.  
  1614. TDSSpec::TDSSpec ( const DSSpec* r ):
  1615.     fPacked ( Allocate ( r ) ),
  1616.     fUnpacked ( nil )
  1617. {
  1618. #if defined ( INTERNAL_CHECKS )
  1619.     ASSERT ( IsValidInternal () );
  1620. #endif
  1621. }
  1622.  
  1623. /***********************************|****************************************/
  1624.  
  1625. TDSSpec::TDSSpec ( const PackedDSSpec* r ):
  1626.     fPacked ( Allocate ( r ) ),
  1627.     fUnpacked ( nil )
  1628. {
  1629. #if defined ( INTERNAL_CHECKS )
  1630.     ASSERT ( IsValidInternal () );
  1631. #endif
  1632. }
  1633.  
  1634. /***********************************|****************************************/
  1635.  
  1636. TDSSpec::TDSSpec ( const DSSpec& r ):
  1637.     fPacked ( Allocate ( &r ) ),
  1638.     fUnpacked ( nil )
  1639. {
  1640. #if defined ( INTERNAL_CHECKS )
  1641.     ASSERT ( IsValidInternal () );
  1642. #endif
  1643. }
  1644.  
  1645. /***********************************|****************************************/
  1646.  
  1647. TDSSpec::TDSSpec ( const PackedDSSpec& r ):
  1648.     fPacked ( Allocate ( &r ) ),
  1649.     fUnpacked ( nil )
  1650. {
  1651. #if defined ( INTERNAL_CHECKS )
  1652.     ASSERT ( IsValidInternal () );
  1653. #endif
  1654. }
  1655.  
  1656.  
  1657. /***********************************|****************************************/
  1658.  
  1659. TDSSpec::TDSSpec ( const TRString& name, const TRString& type, const TPathName& path, const TDirectory& directory,
  1660.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1661.     fPacked ( nil ),
  1662.     fUnpacked ( nil )
  1663. {
  1664.     TRLI rli ( directory, path, 0 );
  1665.     RecordID r;
  1666.     DSSpec d;;
  1667.  
  1668.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1669.     r.local.cid.source = 0;
  1670.     r.local.cid.seq = 0;
  1671.     r.local.recordName = (RString*) (const RString*) name;
  1672.     r.local.recordType = (RString*) (const RString*) type;
  1673.  
  1674.     d.entitySpecifier = & r;    
  1675.     d.extensionType = extensionType;
  1676.     d.extensionSize = extensionLength;
  1677.     d.extensionValue = (char*) extensionData;
  1678.  
  1679.     fPacked = Allocate ( &d );
  1680. #if defined ( INTERNAL_CHECKS )
  1681.     ASSERT ( IsValidInternal () );
  1682. #endif
  1683. }
  1684.  
  1685. /***********************************|****************************************/
  1686.  
  1687. TDSSpec::TDSSpec ( const TRString& name, const TRString& type, const TRLI& rli,
  1688.                     OSType extensionType, const void* extensionData, unsigned long extensionLength ) :
  1689.     fPacked ( nil ),
  1690.     fUnpacked ( nil )
  1691. {
  1692.     RecordID r;
  1693.     DSSpec d;;
  1694.  
  1695.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1696.     r.local.cid.source = 0;
  1697.     r.local.cid.seq = 0;
  1698.     r.local.recordName = (RString*) (const RString*) name;
  1699.     r.local.recordType = (RString*) (const RString*) type;
  1700.  
  1701.     d.entitySpecifier = & r;    
  1702.     d.extensionType = extensionType;
  1703.     d.extensionSize = extensionLength;
  1704.     d.extensionValue = (char*) extensionData;
  1705.  
  1706.     fPacked = Allocate ( &d );
  1707. #if defined ( INTERNAL_CHECKS )
  1708.     ASSERT ( IsValidInternal () );
  1709. #endif
  1710. }
  1711.  
  1712. /***********************************|****************************************/
  1713.  
  1714. TDSSpec::TDSSpec ( const TRString& name, const TRString& type, const DNodeNum node, const TDirectory& directory,
  1715.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1716.     fPacked ( nil ),
  1717.     fUnpacked ( nil )
  1718. {
  1719.     TRLI rli ( directory, node );
  1720.     RecordID r;
  1721.     DSSpec d;
  1722.  
  1723.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1724.     r.local.cid.source = 0;
  1725.     r.local.cid.seq = 0;
  1726.     r.local.recordName = (RString*) (const RString*) name;
  1727.     r.local.recordType = (RString*) (const RString*) type;
  1728.     
  1729.     d.entitySpecifier = & r;    
  1730.     d.extensionType = extensionType;
  1731.     d.extensionSize = extensionLength;
  1732.     d.extensionValue = (char*) extensionData;
  1733.  
  1734.     fPacked = Allocate ( &d );
  1735. #if defined ( INTERNAL_CHECKS )
  1736.     ASSERT ( IsValidInternal () );
  1737. #endif
  1738. }
  1739.  
  1740. /***********************************|****************************************/
  1741.  
  1742. TDSSpec::TDSSpec ( const TCreationID& cid, const TPathName& path, const TDirectory& directory,
  1743.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1744.     fPacked ( nil ),
  1745.     fUnpacked ( nil )
  1746. {
  1747.     TRLI rli ( directory, path );
  1748.     RecordID r;
  1749.     DSSpec d;;
  1750.  
  1751.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1752.     r.local.cid = (CreationID&) (const CreationID&) cid;
  1753.     r.local.recordName = nil;
  1754.     r.local.recordType = nil;
  1755.     
  1756.     d.entitySpecifier = & r;    
  1757.     d.extensionType = extensionType;
  1758.     d.extensionSize = extensionLength;
  1759.     d.extensionValue = (char*) extensionData;
  1760.  
  1761.     fPacked = Allocate ( &d );
  1762. #if defined ( INTERNAL_CHECKS )
  1763.     ASSERT ( IsValidInternal () );
  1764. #endif
  1765. }
  1766.  
  1767. /***********************************|****************************************/
  1768.  
  1769. TDSSpec::TDSSpec ( const TCreationID& cid, const DNodeNum node, const TDirectory& directory,
  1770.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1771.     fPacked ( nil ),
  1772.     fUnpacked ( nil )
  1773. {
  1774.     TRLI rli ( directory, node );
  1775.     RecordID r;
  1776.     DSSpec d;;
  1777.  
  1778.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1779.     r.local.cid = (CreationID&) (const CreationID&) cid;
  1780.     r.local.recordName = nil;
  1781.     r.local.recordType = nil;
  1782.     
  1783.     d.entitySpecifier = & r;    
  1784.     d.extensionType = extensionType;
  1785.     d.extensionSize = extensionLength;
  1786.     d.extensionValue = (char*) extensionData;
  1787.  
  1788.     fPacked = Allocate ( &d );
  1789. #if defined ( INTERNAL_CHECKS )
  1790.     ASSERT ( IsValidInternal () );
  1791. #endif
  1792. }
  1793.  
  1794.  
  1795. /***********************************|****************************************/
  1796.  
  1797. TDSSpec::TDSSpec ( const TCreationID& cid, const TRLI& rli, 
  1798.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ) :
  1799.     fPacked ( nil ),
  1800.     fUnpacked ( nil )
  1801. {
  1802.     RecordID r;
  1803.     DSSpec d;;
  1804.  
  1805.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1806.     r.local.cid = (CreationID&) (const CreationID&) cid;
  1807.     r.local.recordName = nil;
  1808.     r.local.recordType = nil;
  1809.     
  1810.     d.entitySpecifier = & r;    
  1811.     d.extensionType = extensionType;
  1812.     d.extensionSize = extensionLength;
  1813.     d.extensionValue = (char*) extensionData;
  1814.  
  1815.     fPacked = Allocate ( &d );
  1816. #if defined ( INTERNAL_CHECKS )
  1817.     ASSERT ( IsValidInternal () );
  1818. #endif
  1819. }
  1820.  
  1821. /***********************************|****************************************/
  1822.  
  1823. TDSSpec::TDSSpec ( const LocalRecordID& localRecordID, const TPathName& p, const TDirectory& directory,
  1824.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ) :
  1825.     fPacked ( nil ),
  1826.     fUnpacked ( nil )
  1827. {
  1828.     TRLI rli ( directory, p );
  1829.     RecordID r; 
  1830.     DSSpec d;
  1831.  
  1832.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1833.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1834.     r.local.recordName = localRecordID.recordName;
  1835.     r.local.recordType = localRecordID.recordType;
  1836.     
  1837.     d.entitySpecifier = & r;    
  1838.     d.extensionType = extensionType;
  1839.     d.extensionSize = extensionLength;
  1840.     d.extensionValue = (char*) extensionData;
  1841.  
  1842.     fPacked = Allocate ( &d );
  1843. #if defined ( INTERNAL_CHECKS )
  1844.     ASSERT ( IsValidInternal () );
  1845. #endif
  1846. }
  1847.  
  1848. /***********************************|****************************************/
  1849.  
  1850. TDSSpec::TDSSpec ( const LocalRecordID& localRecordID, const DNodeNum node, const TDirectory& directory,
  1851.                         OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1852.     fPacked ( nil ),
  1853.     fUnpacked ( nil )
  1854. {
  1855.     TRLI rli ( directory, node );
  1856.     RecordID r;
  1857.     DSSpec d;;
  1858.  
  1859.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1860.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1861.     r.local.recordName = localRecordID.recordName;
  1862.     r.local.recordType = localRecordID.recordType;
  1863.     
  1864.     d.entitySpecifier = & r;    
  1865.     d.extensionType = extensionType;
  1866.     d.extensionSize = extensionLength;
  1867.     d.extensionValue = (char*) extensionData;
  1868.  
  1869.     fPacked = Allocate ( &d );
  1870. #if defined ( INTERNAL_CHECKS )
  1871.     ASSERT ( IsValidInternal () );
  1872. #endif
  1873. }
  1874.  
  1875. /***********************************|****************************************/
  1876.  
  1877. TDSSpec::TDSSpec ( const LocalRecordID& localRecordID, const TRLI& rli,
  1878.                      OSType extensionType, const void* extensionData, unsigned long extensionLength ):
  1879.     fPacked ( nil ),
  1880.     fUnpacked ( nil )
  1881. {
  1882.     RecordID r;
  1883.     DSSpec d;;
  1884.  
  1885.     r.rli = (PackedRLI*) (const PackedRLI*) rli;
  1886.     OCECopyCreationID(&localRecordID.cid, &r.local.cid);
  1887.     r.local.recordName = localRecordID.recordName;
  1888.     r.local.recordType = localRecordID.recordType;
  1889.     
  1890.     d.entitySpecifier = & r;    
  1891.     d.extensionType = extensionType;
  1892.     d.extensionSize = extensionLength;
  1893.     d.extensionValue = (char*) extensionData;
  1894.  
  1895.     fPacked = Allocate ( &d );
  1896. #if defined ( INTERNAL_CHECKS )
  1897.     ASSERT ( IsValidInternal () );
  1898. #endif
  1899. }
  1900.  
  1901. /***********************************|****************************************/
  1902.  
  1903. TDSSpec::~TDSSpec ()
  1904. {
  1905.     Deallocate ();
  1906. }
  1907.  
  1908. /***********************************|****************************************/
  1909.  
  1910. TDSSpec&
  1911. TDSSpec::operator = ( const DSSpec* r )
  1912. {
  1913. #if defined ( INTERNAL_CHECKS )
  1914.     ASSERT ( r != nil );
  1915. #endif
  1916.  
  1917.     if ( ASSERT ( fUnpacked != r ) )
  1918.     {
  1919.         Deallocate ();
  1920.         fPacked = Allocate ( r );
  1921. #if defined ( INTERNAL_CHECKS )
  1922.         ASSERT ( IsValidInternal () );
  1923. #endif
  1924.     }
  1925.  
  1926.     return *this;
  1927. }
  1928.  
  1929. /***********************************|****************************************/
  1930.  
  1931. TDSSpec&
  1932. TDSSpec::operator = ( const PackedDSSpec* r )
  1933. {
  1934.     if ( ASSERT ( fPacked != r ) )
  1935.     {
  1936.         Deallocate ();
  1937.         fPacked = Allocate ( r );
  1938. #if defined ( INTERNAL_CHECKS )
  1939.         ASSERT ( IsValidInternal () );
  1940. #endif
  1941.     }
  1942.  
  1943.     return *this;
  1944. }
  1945.  
  1946. /***********************************|****************************************/
  1947.  
  1948. Boolean
  1949. TDSSpec::operator == ( const DSSpec* r ) const
  1950. {
  1951. #if defined ( INTERNAL_CHECKS )
  1952.     if ( ASSERT ( IsValidInternal ( r ) ) )
  1953. #endif
  1954.         if ( ASSERT ( ValidateUnpackedAndCheck () ) )
  1955.             return ::OCEEqualDSSpec ( fUnpacked, r );
  1956.  
  1957.     return false;
  1958. }
  1959.  
  1960. /***********************************|****************************************/
  1961.  
  1962. Boolean TDSSpec::operator == ( const PackedDSSpec* p ) const
  1963. {
  1964. #if defined ( INTERNAL_CHECKS )
  1965.     if ( ASSERT ( IsValidInternal ( p ) ) )
  1966. #endif
  1967.         if ( ASSERT ( IsValidInternal ( fPacked ) ) )
  1968.             return ::OCEEqualPackedDSSpec ( fPacked, p );
  1969.  
  1970.     return false;
  1971. }
  1972.  
  1973. /***********************************|****************************************/
  1974.  
  1975. Boolean
  1976. TDSSpec::Adopt ( PackedDSSpec* p )
  1977. {
  1978.     ASSERT_RETURN_ZERO ( IsValid ( p ) && ( p != fPacked ) );
  1979.     Deallocate ();
  1980.     fPacked = p;
  1981.     return true;
  1982. }
  1983.  
  1984. /***********************************|****************************************/
  1985.  
  1986. Boolean
  1987. TDSSpec::Set ( const DSSpec* r )
  1988. {
  1989.     // it is quite possible that the DSSpec* passed in could
  1990.     // be our unpacked cache, so be careful about deleting or
  1991.     // invalidating or unpacked cache or deleting our pack storage!
  1992.  
  1993. #if defined ( INTERNAL_CHECKS )
  1994.     ASSERT_RETURN_ZERO ( IsValidInternal ( r ) );
  1995. #endif
  1996.     PackedDSSpec* newPacked = Allocate ( r );
  1997. #if defined ( INTERNAL_CHECKS )
  1998.     ASSERT_RETURN_ZERO ( IsValidInternal ( newPacked ) );
  1999. #endif
  2000.     Deallocate ();
  2001.     fPacked = newPacked;
  2002.     return true;
  2003. }
  2004.  
  2005. /***********************************|****************************************/
  2006.  
  2007. Boolean
  2008. TDSSpec::Set ( const PackedRLI* rli )
  2009. {
  2010. #if defined ( INTERNAL_CHECKS )
  2011.     ASSERT_RETURN_ZERO ( TRLI::IsValid ( rli ) );
  2012. #endif
  2013.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2014.     PackedRLI* prevRLI = fUnpacked->entitySpecifier->rli;
  2015.     fUnpacked->entitySpecifier->rli = (PackedRLI*) rli;
  2016.  
  2017.     if ( Set ( fUnpacked ) )
  2018.     {
  2019.         return true;
  2020.     }
  2021.     else
  2022.     {
  2023.         fUnpacked->entitySpecifier->rli = prevRLI;
  2024.         return false;
  2025.     }
  2026. }
  2027.  
  2028. /***********************************|****************************************/
  2029.  
  2030. Boolean
  2031. TDSSpec::SetRecordName ( const TRString& string )
  2032. {
  2033.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2034.     RString* prevName = fUnpacked->entitySpecifier->local.recordName;
  2035.     fUnpacked->entitySpecifier->local.recordName = (RString*) (const RString*) string;
  2036.  
  2037.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  2038.     {
  2039.         return true;
  2040.     }
  2041.     else
  2042.     {
  2043.         fUnpacked->entitySpecifier->local.recordName = prevName;
  2044.         return false;
  2045.     }
  2046. }
  2047.  
  2048. /***********************************|****************************************/
  2049.  
  2050. Boolean
  2051. TDSSpec::GetRecordName ( TRString& string ) const
  2052. {
  2053.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2054.     string = fUnpacked->entitySpecifier->local.recordName;
  2055.     return true;
  2056. }
  2057.  
  2058. /***********************************|****************************************/
  2059.  
  2060. Boolean
  2061. TDSSpec::SetRecordType ( const TRString& string )
  2062. {
  2063.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2064.     RString* prevType = fUnpacked->entitySpecifier->local.recordType;
  2065.     fUnpacked->entitySpecifier->local.recordType = (RString*) (const RString*) string;
  2066.  
  2067.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  2068.     {
  2069.         return true;
  2070.     }
  2071.     else
  2072.     {
  2073.         fUnpacked->entitySpecifier->local.recordType = prevType;
  2074.         return false;
  2075.     }
  2076. }
  2077.  
  2078. /***********************************|****************************************/
  2079.  
  2080. Boolean
  2081. TDSSpec::GetRecordType ( TRString& string ) const
  2082. {
  2083.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2084.     string = fUnpacked->entitySpecifier->local.recordType;
  2085.     return true;
  2086. }
  2087.  
  2088. /***********************************|****************************************/
  2089.  
  2090. Boolean
  2091. TDSSpec::SetCreationID ( const TCreationID& cid )
  2092. {
  2093.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2094.     CreationID prevID = fUnpacked->entitySpecifier->local.cid;
  2095.     fUnpacked->entitySpecifier->local.cid = (CreationID&) (const CreationID&) cid;
  2096.  
  2097.     if ( Adopt ( Allocate ( fUnpacked ) ) )
  2098.     {
  2099.         return true;
  2100.     }
  2101.     else
  2102.     {
  2103.         fUnpacked->entitySpecifier->local.cid = prevID;
  2104.         return false;
  2105.     }
  2106. }
  2107.  
  2108. /***********************************|****************************************/
  2109.  
  2110. Boolean
  2111. TDSSpec::GetCreationID ( TCreationID& cid ) const
  2112. {
  2113.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2114.     cid = fUnpacked->entitySpecifier->local.cid;
  2115.     return true;
  2116. }
  2117.  
  2118. /***********************************|****************************************/
  2119.  
  2120. Boolean
  2121. TDSSpec::SetNode ( const DNodeNum node )
  2122. {
  2123.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2124.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2125.     rli.SetNode ( node );
  2126.     return Set ( rli );
  2127. }
  2128.  
  2129. /***********************************|****************************************/
  2130.  
  2131. DNodeNum
  2132. TDSSpec::GetNode () const
  2133. {
  2134.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2135.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2136.     return rli.GetNode ();
  2137. }
  2138.  
  2139. /***********************************|****************************************/
  2140.  
  2141. Boolean
  2142. TDSSpec::SetPathName ( const TPathName& path )
  2143. {
  2144.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2145.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2146.     rli.SetPathName ( path );
  2147.     return Set ( rli );
  2148. }
  2149.  
  2150. /***********************************|****************************************/
  2151.  
  2152. Boolean
  2153. TDSSpec::GetPathName ( TPathName& path ) const
  2154. {
  2155.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2156.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2157.     return rli.GetPathName ( path );
  2158. }
  2159.  
  2160. /***********************************|****************************************/
  2161.  
  2162. Boolean
  2163. TDSSpec::SetDirectory ( const TDirectory& directory )
  2164. {
  2165.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2166.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2167.     rli.SetDirectory ( directory );
  2168.     return Set ( rli );
  2169. }
  2170.  
  2171. /***********************************|****************************************/
  2172.  
  2173. Boolean
  2174. TDSSpec::GetDirectory ( TDirectory& directory ) const
  2175. {
  2176.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2177.     TRLI rli ( fUnpacked->entitySpecifier->rli );
  2178.     return rli.GetDirectory ( directory );
  2179. }
  2180.  
  2181. /***********************************|****************************************/
  2182.  
  2183. Boolean
  2184. TDSSpec::SetRLI ( const TRLI& rli )
  2185. {
  2186.     return Set ( rli );
  2187. }
  2188.  
  2189. /***********************************|****************************************/
  2190.  
  2191. Boolean
  2192. TDSSpec::GetRLI ( TRLI& rli ) const
  2193. {
  2194.     ASSERT_RETURN_ZERO ( ValidateUnpackedAndCheck () );
  2195.     rli = TRLI ( fUnpacked->entitySpecifier->rli );
  2196.     return true;
  2197. }
  2198.  
  2199. /***********************************|****************************************/
  2200.  
  2201. TDSSpec::operator const DSSpec* () const
  2202. {
  2203.     ValidateUnpackedAndCheck ();
  2204.     return fUnpacked;
  2205. }
  2206.  
  2207. /***********************************|****************************************/
  2208.  
  2209. TDSSpec::operator const DSSpec& () const
  2210. {
  2211.     ValidateUnpacked ();
  2212.     return *fUnpacked;
  2213. }
  2214.  
  2215. /***********************************|****************************************/
  2216.  
  2217. OSType TDSSpec::GetExtensionType () const
  2218. {
  2219.     ValidateUnpacked ();
  2220.     if ( fUnpacked )
  2221.         return fUnpacked->extensionType;
  2222.     else
  2223.         return kOCEInvalidDSSpec;
  2224. }
  2225.  
  2226. /***********************************|****************************************/
  2227.  
  2228. unsigned long TDSSpec::GetExtensionSize () const
  2229. {
  2230.     ValidateUnpacked ();
  2231.     if ( fUnpacked )
  2232.         return fUnpacked->extensionSize;
  2233.     else
  2234.         return 0;
  2235. }
  2236.  
  2237. /***********************************|****************************************/
  2238.  
  2239. const void * TDSSpec::GetExtensionValue () const
  2240. {
  2241.     ValidateUnpacked ();
  2242.     if ( fUnpacked )
  2243.         return (const void *) fUnpacked->extensionValue;
  2244.     else
  2245.         return 0;
  2246. }
  2247.  
  2248. /***********************************|****************************************/
  2249.  
  2250. Boolean
  2251. TDSSpec::Write ( TAbstractFile& f ) const
  2252. {
  2253. #if defined ( INTERNAL_CHECKS )
  2254.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  2255. #endif
  2256.     unsigned short physicalSize = GetPhysicalSize ( fPacked );
  2257.     ASSERT_RETURN_ZERO ( f.Write ( physicalSize ) == noErr );
  2258.     ASSERT_RETURN_ZERO ( f.WriteDataIgnore ( fPacked, physicalSize ) == noErr );
  2259.     return true;
  2260. }
  2261.  
  2262. /***********************************|****************************************/
  2263.  
  2264. Boolean
  2265. TDSSpec::Read ( TAbstractFile& f )
  2266. {
  2267.     unsigned short physicalSize = 0;
  2268.     ASSERT_RETURN_ZERO ( f.Read ( physicalSize ) == noErr );
  2269.     ASSERT_RETURN_ZERO ( physicalSize >= sizeof ( ProtoPackedDSSpec ) );
  2270.     PackedDSSpec* newPacked = Allocate ( physicalSize );
  2271.     ASSERT_RETURN_ZERO ( newPacked != nil );
  2272.     ASSERT_RETURN_ZERO ( f.ReadDataIgnore ( newPacked, physicalSize ) == noErr );
  2273.     Deallocate ();
  2274.     fPacked = newPacked;
  2275. #if defined ( INTERNAL_CHECKS )
  2276.     ASSERT_RETURN_ZERO ( IsValidInternal () );
  2277. #endif
  2278.     return true;
  2279. }
  2280.  
  2281. /***********************************|****************************************/
  2282.  
  2283. ostream&
  2284. TDSSpec::operator >> ( ostream& s ) const
  2285. {
  2286.     if ( ASSERT ( ValidateUnpackedAndCheck () ) )
  2287.     {
  2288.         s << "rli: " << fUnpacked->entitySpecifier->rli;
  2289.         s << "\ncid: " << fUnpacked->entitySpecifier->local.cid;
  2290.         s << ", recordName: " << fUnpacked->entitySpecifier->local.recordName;
  2291.         s << ", recordType: " << fUnpacked->entitySpecifier->local.recordType;
  2292.     }
  2293.     else
  2294.     {
  2295.         s << "fPacked: " << fPacked;
  2296.     }
  2297.  
  2298.     return s;
  2299. }
  2300.  
  2301.  
  2302.  
  2303.  
  2304. /***********************************|****************************************/
  2305.  
  2306. static void Print ( ostream& s, const OSType x )
  2307. {
  2308.     union { OSType o; char s [ 5 ]; } u;
  2309.  
  2310.     u.o = x;
  2311.     u.s [ 4 ] = '\0';
  2312.  
  2313.     s << '‘' << u.s << '’';
  2314. }
  2315.  
  2316. /***********************************|****************************************/
  2317.  
  2318. ostream& operator << ( ostream& s, const RString* x )
  2319. {
  2320.     if ( x )
  2321.         s << *x;
  2322.     else
  2323.         s << "<NIL>";
  2324.  
  2325.     return s;
  2326. }
  2327.  
  2328. /***********************************|****************************************/
  2329.  
  2330. ostream& operator << ( ostream& s, const RString& x )
  2331. {
  2332.     const unsigned short p = x.dataLength;
  2333.  
  2334.     s << '[';
  2335.  
  2336.     if ( p > 0 )
  2337.     {
  2338.         Byte c = ( (RString&) x ).body [ p ];
  2339.          ( (RString&) x ).body [ p ] = '\0';
  2340.         s << (const char*) x.body;
  2341.          ( (RString&) x ).body [ p ] = c;
  2342.     }
  2343.  
  2344.     if ( x.charSet != smRoman )
  2345.         s << '(' << (short) x.charSet << ')';
  2346.  
  2347.      return s << ']' << flush;
  2348. }
  2349.  
  2350. /***********************************|****************************************/
  2351.  
  2352. ostream& operator << ( ostream& st, const CreationID& xa )
  2353. {
  2354.     st << (unsigned long) xa.source;
  2355.     return st;
  2356. }
  2357.  
  2358. /***********************************|****************************************/
  2359.  
  2360. #if 0
  2361. ostream& operator << ( ostream& s, const CreationID* x )
  2362. {
  2363.     if ( x )
  2364.         return s << *x;
  2365.     else
  2366.         return s << "<NIL>";
  2367. }
  2368. #endif
  2369.  
  2370. /***********************************|****************************************/
  2371.  
  2372. #if 1
  2373. ostream& operator << ( ostream& s, const PackedPathName* x )
  2374. {
  2375.     if ( x )
  2376.     {    
  2377.         s << *x;
  2378.     }
  2379.     else
  2380.         s << "<NIL>";
  2381.         
  2382.     return s;
  2383. }
  2384. #endif
  2385.  
  2386. /***********************************|****************************************/
  2387.  
  2388. ostream& operator << ( ostream& s, const PackedPathName& x )
  2389. {
  2390.     if ( ::OCEIsNullPackedPathName ( &x ) )
  2391.     {
  2392.         s << "<NULL PATHNAME>";
  2393.     }
  2394.     else
  2395.     {
  2396.         unsigned short count = (x.dataLength > 0) ? ::OCEDNodeNameCount ( &x ) : 0;
  2397.         ConstRStringPtr* r = (ConstRStringPtr*) FAILNewPtrClear ( count * sizeof ( ConstRStringPtr ) );
  2398.  
  2399.         if ( ASSERT ( r != nil ) )
  2400.         {
  2401.             if ( ASSERT ( ::OCEUnpackPathName ( &x, (RString* const *) r, count ) == count ) )
  2402.             {
  2403.                 for ( unsigned short index = 0; index < count; index++ )
  2404.                 {
  2405.                     if ( index > 0 )
  2406.                         s << ':';
  2407.  
  2408.                     s << r [ index ];
  2409.                 }
  2410.             }
  2411.  
  2412.             ::DeallocatePtr( (Ptr) r );
  2413. #if defined ( INTERNAL_CHECKS )
  2414.             ASSERT ( MemError () == noErr );
  2415. #endif
  2416.         }
  2417.     }
  2418.  
  2419.     return s;
  2420. }
  2421.  
  2422. /***********************************|****************************************/
  2423.  
  2424. ostream& operator << ( ostream& s, const DirDiscriminator* x )
  2425. {
  2426.     if ( x )
  2427.         return s << *x;
  2428.     else
  2429.         return s << "<NIL>";
  2430. }
  2431.  
  2432. /***********************************|****************************************/
  2433.  
  2434. ostream& operator << ( ostream& s, const DirDiscriminator& x )
  2435. {
  2436.     Print ( s, (const OSType) x.signature );
  2437.  
  2438.     if ( x.misc != 0 )
  2439.         s << " (" << x.misc << ')';
  2440.  
  2441.     return s;
  2442. }
  2443.  
  2444. /***********************************|****************************************/
  2445.  
  2446. #ifndef THINK_CPLUS
  2447. ostream& operator << ( ostream& s, const DirectoryName* x )
  2448. {
  2449.     if ( x )
  2450.         return s << *x;
  2451.     else
  2452.         return s << "<NIL>";
  2453. }
  2454. #endif
  2455.  
  2456. /***********************************|****************************************/
  2457.  
  2458. ostream& operator << ( ostream& s, const DirectoryName& x )
  2459. {
  2460.     const unsigned short p = x.dataLength;
  2461.  
  2462.     s << '[';
  2463.  
  2464.     if ( p > 0 )
  2465.     {
  2466.         Byte c = ( (RString&) x ).body [ p ];
  2467.          ( (RString&) x ).body [ p ] = '\0';
  2468.         s << (const char*) x.body;
  2469.          ( (RString&) x ).body [ p ] = c;
  2470.     }
  2471.  
  2472.     if ( x.charSet != smRoman )
  2473.         s << '(' << (short) x.charSet << ')';
  2474.  
  2475.      return s << ']' << flush;
  2476. }
  2477.  
  2478. /***********************************|****************************************/
  2479.  
  2480. ostream& operator << ( ostream& s, const RLI* x )
  2481. {
  2482.     if ( x )
  2483.         return s << *x;
  2484.     else
  2485.         return s << "<NIL>";
  2486. }
  2487.  
  2488. /***********************************|****************************************/
  2489.  
  2490. ostream& operator << ( ostream& s, const RLI& x )
  2491. {
  2492.     s << "directoryName:";
  2493.     operator << ( s, * (RStringPtr) x.directoryName );
  2494.     s << ", discriminator:";
  2495.     operator << ( s,  x.discriminator );
  2496.     s << ", dNodeNumber:" << x.dNodeNumber << ", path:" << x.path;
  2497.     return s;
  2498. }
  2499.  
  2500. /***********************************|****************************************/
  2501.  
  2502. ostream& operator << ( ostream& s, const PackedRLI* x )
  2503. {
  2504.     if ( x )
  2505.         return s << *x;
  2506.     else
  2507.         return s << "<NIL>";
  2508. }
  2509.  
  2510. /***********************************|****************************************/
  2511.  
  2512. ostream& operator << ( ostream& s, const PackedRLI& x )
  2513. {
  2514.     RLI rli;
  2515.     ::OCEUnpackRLI ( &x, &rli );
  2516.     operator << ( s, rli );
  2517.     return s ;
  2518. }
  2519.  
  2520. /***********************************|****************************************/
  2521.  
  2522. ostream& operator << ( ostream& s, const RecordID* x )
  2523. {
  2524.     if ( x )
  2525.         return s << *x;
  2526.     else
  2527.         return s << "<NIL>";
  2528. }
  2529.  
  2530. /***********************************|****************************************/
  2531.  
  2532. ostream& operator << ( ostream& s, const RecordID& x )
  2533. {
  2534.     s << "recordName:" << x.local.recordName << ", recordType:" << x.local.recordType;
  2535.     s << " rli: {" << x.rli << "}, cid:" << hex << x.local.cid.source << " " << hex << x.local.cid.seq << dec;
  2536.     return s;
  2537. }
  2538.  
  2539. /***********************************|****************************************/
  2540.  
  2541. ostream& operator << ( ostream& s, const PackedRecordID* x )
  2542. {
  2543.     if ( x )
  2544.         return s << *x;
  2545.     else
  2546.         return s << "<NIL>";
  2547. }
  2548.  
  2549. /***********************************|****************************************/
  2550.  
  2551. ostream& operator << ( ostream& s, const PackedRecordID& x )
  2552. {
  2553.     RecordID r;
  2554.     ::OCEUnpackRecordID ( &x, &r );
  2555.     // return s << r;
  2556.     return s << "NOT IMPLEMENTED";
  2557. }
  2558.  
  2559. /***********************************|****************************************/
  2560.